{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Distributional Q-learning on Atari Freeway\n",
    "### Code for Chapter 7 of _Deep Reinforcement Learning in Action_ \n",
    "#### by Alex Zai and Brandon Brown\n",
    "An implementation of \"A Distributional Perspective on Reinforcement Learning\" by Bellemare et al 2017"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from random import shuffle\n",
    "import gym\n",
    "from collections import deque\n",
    "import skvideo.io\n",
    "from skimage.transform import resize\n",
    "from skimage import img_as_ubyte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "workdir = \"/Users/brandonbrown/Dropbox/DeepReinforcementLearning/media/Ch 7/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the gym environment for Atari Freeway.\n",
    "To simplify the algorithm and focus on the topics of interest, we use the ram version of Freeway rather than the raw pixels. In the ram version, the environment's states are 128-element vectors as opposed to RGB frames. This allows us to use a much simpler (i.e. non-convolutional, fewer layers) neural network so we can see the results of training faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['NOOP', 'UP', 'DOWN']"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env = gym.make('Freeway-ram-v0')\n",
    "aspace = 3\n",
    "env.env.get_action_meanings()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_dist(r,support,probs,lim=(-10.,10.),gamma=0.8):\n",
    "    \"\"\"\n",
    "    This function takes a discrete probability distribution over the range of rewards\n",
    "    and updates the distribution based on a single new reward observation.\n",
    "    `r` is a float indicating the observed reward\n",
    "    `support`, is a vector of the distribution's support, e.g. uniformly spaced numbers from -10 to +10\n",
    "    `probs`, is the vector of probabilities over `support`\n",
    "    `lim`, tuple of floats, are the lower and upper limits of the support\n",
    "    `gamma`, float, is the discount factor\n",
    "    \"\"\"\n",
    "    nsup = probs.shape[0]\n",
    "    vmin,vmax = lim[0],lim[1]\n",
    "    dz = (vmax-vmin)/(nsup-1.)\n",
    "    bj = np.round((r-vmin)/dz)\n",
    "    bj = int(np.clip(bj,0,nsup-1))\n",
    "    m = probs.clone()\n",
    "    j = 1\n",
    "    for i in range(bj,1,-1):\n",
    "        m[i] += np.power(gamma,j) * m[i-1]\n",
    "        j += 1\n",
    "    j = 1\n",
    "    for i in range(bj,nsup-1,1):\n",
    "        m[i] += np.power(gamma,j) * m[i+1]\n",
    "        j += 1\n",
    "    m /= m.sum()\n",
    "    return m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see an example of how `update_dist` works. We first create a uniform discrete distribution over the support of evenly spaced numbers from -10 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 51 artists>"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9,7))\n",
    "vmin,vmax=-10.,10.\n",
    "nsup=51\n",
    "support = np.linspace(vmin,vmax,nsup)\n",
    "probs = np.ones(nsup)\n",
    "probs /= probs.sum()\n",
    "Z = torch.from_numpy(probs).float()\n",
    "plt.bar(support,probs)\n",
    "#plt.savefig(workdir + \"uniform_dist.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how observing a single reward updates the distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 51 artists>"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9,7))\n",
    "ob_reward = -1\n",
    "Z = update_dist(ob_reward, torch.from_numpy(support).float(), Z, lim=(vmin,vmax), gamma=0.1)\n",
    "plt.bar(support, Z)\n",
    "#plt.savefig(workdir + \"posterior_dist_1reward.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we simulate observing a sequence of rewards and see how it changes the distribution. You will see little peaks at the observed rewards but it is still fairly uniform. Try changing the `gamma` to see how this affects the distribution updating. A small `gamma` will result in small updates from prior to posterior distribution, whereas a `gamma` closer to `1` will result in large updates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9,7))\n",
    "ob_rewards = [10,10,10,0,1,0,-10,-10,10,10]\n",
    "for i in range(len(ob_rewards)):\n",
    "    Z = update_dist(ob_rewards[i], torch.from_numpy(support).float(), Z, lim=(vmin,vmax), gamma=0.7)\n",
    "plt.bar(support, Z)\n",
    "#plt.savefig(workdir + \"posterior_dist1_rseq.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10. ,  -9.6,  -9.2,  -8.8,  -8.4,  -8. ,  -7.6,  -7.2,  -6.8,\n",
       "        -6.4,  -6. ,  -5.6,  -5.2,  -4.8,  -4.4,  -4. ,  -3.6,  -3.2,\n",
       "        -2.8,  -2.4,  -2. ,  -1.6,  -1.2,  -0.8,  -0.4,   0. ,   0.4,\n",
       "         0.8,   1.2,   1.6,   2. ,   2.4,   2.8,   3.2,   3.6,   4. ,\n",
       "         4.4,   4.8,   5.2,   5.6,   6. ,   6.4,   6.8,   7.2,   7.6,\n",
       "         8. ,   8.4,   8.8,   9.2,   9.6,  10. ])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "support"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_target_dist(dist_batch,action_batch,reward_batch,support,lim=(-10,10),gamma=0.8):\n",
    "    \"\"\"\n",
    "    Given a mini-batch of Q-value distribution predictions,\n",
    "    this function produces the target distribution used in the loss\n",
    "    function to update the DQN\n",
    "    \n",
    "    `dist_batch`: Ax51xB where A is the action space size and B is batch size\n",
    "    `action_batch`: dim=B vector of integers in {0,1,2} of actions\n",
    "    `reward_batch`: dim=B vector of floats\n",
    "    `lim`:2-tuple, indicates the lower and upper bound of the support\n",
    "    `gamma`, float in [0,1], the discount factor\n",
    "    \"\"\"\n",
    "    nsup = support.shape[0]\n",
    "    vmin,vmax = lim[0],lim[1]\n",
    "    dz = (vmax-vmin)/(nsup-1.)\n",
    "    #\n",
    "    target_dist_batch = dist_batch.clone()\n",
    "    #\n",
    "    for i in range(dist_batch.shape[0]): #loop through batch dimension\n",
    "        dist_full = dist_batch[i]\n",
    "        action = int(action_batch[i].item())\n",
    "        dist = dist_full[action]\n",
    "        r = reward_batch[i]\n",
    "        if r != -1: #terminal state, target is degenerate distribuation at reward\n",
    "            target_dist = torch.zeros(nsup)\n",
    "            bj = np.round((r-vmin)/dz)\n",
    "            bj = int(np.clip(bj,0,nsup-1))\n",
    "            target_dist[bj] = 1.\n",
    "        else:\n",
    "            target_dist = update_dist(r,support,dist,lim=lim,gamma=gamma)\n",
    "        target_dist_batch[i,action,:] = target_dist\n",
    "        \n",
    "    return target_dist_batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dist_dqn(x,theta,aspace=3):\n",
    "    \"\"\"\n",
    "    3 layer neural network\n",
    "    `x` is input vector of dim 128\n",
    "    `theta` is a parameter vector that will be unpacked into 3 separate layer matrices\n",
    "        layer1: L1 x X -> 100x128 x 128xB -> 100xB\n",
    "        layer2: L2 x L1 -> 25x100 x 100xB -> 25xB\n",
    "        layer3: L3 x L2 -> 3x25x51 x 25xB -> 3x51xB\n",
    "        where `B` is the batch size dimension\n",
    "        \n",
    "    Returns a Batch Sizex A x 51 tensor where A is the action-space size\n",
    "    \"\"\"\n",
    "    dim0 = 128\n",
    "    dim1 = 100\n",
    "    dim2 = 25\n",
    "    dim3 = 51\n",
    "    t1 = dim0*dim1\n",
    "    t2 = dim2*dim1\n",
    "    theta1 = theta[0:t1].reshape(dim0,dim1)\n",
    "    theta2 = theta[t1:t1 + t2].reshape(dim1,dim2)\n",
    "    #\n",
    "    l1 = x @ theta1 #B x 128 x 128 x 100 = B x 100\n",
    "    l1 = torch.selu(l1)\n",
    "    l2 = l1 @ theta2 # B x 100 x 100 x 25 = B x 25\n",
    "    l2 = torch.selu(l2)\n",
    "    l3 = []\n",
    "    for i in range(aspace):\n",
    "        step = dim2*dim3\n",
    "        theta5_dim = t1 + t2 + i * step\n",
    "        theta5 = theta[theta5_dim:theta5_dim+step].reshape(dim2,dim3)\n",
    "        l3_ = l2 @ theta5 #B x 25 x 25 x 51 = B x 51\n",
    "        l3.append(l3_)\n",
    "    l3 = torch.stack(l3,dim=1) # B x 3 x 51\n",
    "    l3 = torch.nn.functional.softmax(l3,dim=2)\n",
    "    return l3.squeeze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_action(dist,support):\n",
    "    \"\"\"\n",
    "    This function returns an integer action in [0,1,2]\n",
    "    `dist` input is a Ax51xB discrete distribution over Q-values for each action\n",
    "    where `A` is the action-space size, and `B` is the batch dimension.\n",
    "    Get expectations w.r.t. to each action, take action w/ highest q-value\n",
    "    \n",
    "    Output:\n",
    "    - `actions`: vector of integers in {0,1,2}, dimension dist.shape[0] (batch size)\n",
    "    \"\"\"\n",
    "    actions = []\n",
    "    for b in range(dist.shape[0]): #loop through batch dimension\n",
    "        expectations = [support @ dist[b,a,:] for a in range(dist.shape[1])]\n",
    "        action = int(np.argmax(expectations))\n",
    "        actions.append(action)\n",
    "    actions = torch.Tensor(actions).int()\n",
    "    return actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lossfn(x,y):\n",
    "    \"\"\"\n",
    "    Cross-Entropy Loss between prediction distribution `x` and target distribution `y`\n",
    "    `x`: B x A x 51 tensor where `B` is batch dimension, `A` is action dimension\n",
    "    `y` is B x A x 51 tensor\n",
    "    \n",
    "    Output\n",
    "    - `loss`: Float\n",
    "    \"\"\"\n",
    "    loss = torch.Tensor([0.])\n",
    "    loss.requires_grad=True\n",
    "    for i in range(x.shape[0]): #loop through batch dimension\n",
    "        loss_ = -1 *  torch.log(x[i].flatten(start_dim=0)) @ y[i].flatten(start_dim=0)\n",
    "        loss = loss + loss_\n",
    "    return loss\n",
    "\n",
    "def preproc_state(state):\n",
    "    \"\"\"\n",
    "    Takes numpy array from env.reset or env.step\n",
    "    and converts to PyTorch Tensor, adds batch dimension and normalizes\n",
    "    \n",
    "    Output:\n",
    "    - `p_state`: PyTorch tensor of dimensions 1x128\n",
    "    \"\"\"\n",
    "    p_state = torch.from_numpy(state).unsqueeze(dim=0).float()\n",
    "    p_state = torch.nn.functional.normalize(p_state,dim=1)\n",
    "    #\n",
    "    return p_state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dist_plot(env,dist,support,shape=(105,80,3)):\n",
    "    \"\"\"\n",
    "    This function renders a side-by-side RGB image (returned as numpy array)\n",
    "    of the current environment state (left) next to the current predicted probability distribution\n",
    "    over rewards.\n",
    "    \n",
    "    `env` OpenAI Gym instantiated environment object\n",
    "    `dist`: A x 51 tensor , where `A` is action space dimension\n",
    "    `support` vector of supports\n",
    "    `shape` (RGB: width,height,channels) desired output image size\n",
    "    \n",
    "    Output:\n",
    "    - numpy array of RGB image (w,ht,ch)\n",
    "    \"\"\"\n",
    "    cs = ['cyan','yellow','red','green','magenta']\n",
    "    fig,ax=plt.subplots(1,1)\n",
    "    fig.set_size_inches(5,5)\n",
    "    for i in range(dist.shape[0]): #loop through actions\n",
    "        _ = ax.bar(support.data.numpy(),dist[i,:].data.numpy(),\\\n",
    "                label='{}'.format(env.env.get_action_meanings()[i]),alpha=0.9,color=cs[i])\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "    support_ = np.linspace(support.min(),support.max(),5)\n",
    "    ax.set_xticks(support_)\n",
    "    ax.set_xticklabels(support_)\n",
    "    ax.xaxis.label.set_color('white')\n",
    "    ax.tick_params(axis='both', which='major', labelsize=20)\n",
    "    ax.tick_params(axis='x', colors='white')\n",
    "    fig.set_facecolor('black')\n",
    "    ax.set_facecolor('black')\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    fig.legend(loc='upper left',prop={'size': 20})\n",
    "    plt.close(fig)\n",
    "    width, height = fig.get_size_inches() * fig.get_dpi()\n",
    "    width,height=int(width),int(height)\n",
    "    fig.canvas.draw()\n",
    "    image1 = np.fromstring(fig.canvas.tostring_rgb(), sep='', dtype='uint8').reshape(height,width,3)\n",
    "    image2 = resize(image1,shape)\n",
    "    image2 = img_as_ubyte(image2)\n",
    "    state_render = img_as_ubyte(resize(env.render('rgb_array'),shape))\n",
    "    image3 = np.hstack((state_render,image2))\n",
    "    return image3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Testing with Random Distributions\n",
    "\n",
    "To test the Dist-DQN and other functions, we train the dist-DQN to learn the reward distributions for 2 observed states (randomly created)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initialize DQN parameter vector\n",
    "aspace = 3\n",
    "tot_params = 128*100 + 25*100 + aspace*25*51\n",
    "theta = torch.randn(tot_params)/10.\n",
    "theta.requires_grad=True\n",
    "theta_2 = theta.detach().clone() #initialize paramaters for target network\n",
    "#\n",
    "vmin,vmax= -10,10\n",
    "gamma=0.9\n",
    "lr = 0.00001\n",
    "update_rate = 75\n",
    "support = torch.linspace(-10,10,51)\n",
    "state = torch.randn(2,128)/10.\n",
    "action_batch = torch.Tensor([0,2])\n",
    "reward_batch = torch.Tensor([0,10])\n",
    "losses = []\n",
    "pred_batch = dist_dqn(state,theta,aspace=aspace)\n",
    "target_dist = get_target_dist(pred_batch2,action_batch,reward_batch, \\\n",
    "                                 support, lim=(vmin,vmax),gamma=gamma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training loop\n",
    "for i in range(1000):\n",
    "    reward_batch = torch.Tensor([0,8]) + torch.randn(2)/10.0 #add some random noise to rewards to make it harder\n",
    "    pred_batch = dist_dqn(state,theta,aspace=aspace)\n",
    "    pred_batch2 = dist_dqn(state,theta_2,aspace=aspace)\n",
    "    target_dist = get_target_dist(pred_batch2,action_batch,reward_batch, \\\n",
    "                                 support, lim=(vmin,vmax),gamma=gamma)\n",
    "    loss = lossfn(pred_batch,target_dist.detach())\n",
    "    losses.append(loss.item())\n",
    "    loss.backward()\n",
    "    # Gradient Descent\n",
    "    with torch.no_grad():\n",
    "        theta -= lr * theta.grad\n",
    "    theta.requires_grad = True\n",
    "    \n",
    "    if i % update_rate == 0: #sync target network parameters with main model parameters\n",
    "        theta_2 = theta.detach().clone()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how well the last prediction matches the target distribution. If `gamma` is very low, they will match well even without training since the target distribution will only be a very slight update of the starting distribution. If `gamma` is high, it will take many iterations of training before they become well-matched."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9,7))\n",
    "plt.plot((target_dist.flatten(start_dim=1)[0].data.numpy()),color='red',label='target')\n",
    "plt.plot((pred_batch.flatten(start_dim=1)[0].data.numpy()),color='green',label='pred')\n",
    "plt.legend()\n",
    "#plt.savefig(workdir+\"dqntest_comparison_untrained.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9,7))\n",
    "plt.plot(losses)\n",
    "#plt.savefig(workdir+\"dqntest_losses.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tpred = pred_batch\n",
    "cs = ['gray','green','red']\n",
    "num_batch = 2\n",
    "labels = ['Action {}'.format(i,) for i in range(aspace)]\n",
    "fig,ax = plt.subplots(nrows=num_batch,ncols=aspace)\n",
    "fig.set_size_inches((15,5))\n",
    "\n",
    "for j in range(num_batch): #loop through 5 first experiences in batch\n",
    "    for i in range(tpred.shape[1]): #loop through actions\n",
    "        ax[j,i].bar(support.data.numpy(),tpred[j,i,:].data.numpy(),\\\n",
    "                label='Action {}'.format(i),alpha=0.9,color=cs[i])\n",
    "\n",
    "#fig.savefig(workdir+\"distdqn_test_batch_dist_plot.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dist-DQN on Atari Freeway"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "vmin,vmax = -10,10\n",
    "replay_size = 200\n",
    "batch_size = 50\n",
    "nsup = 51\n",
    "dz = (vmax - vmin) / (nsup-1)\n",
    "support = torch.linspace(vmin,vmax,nsup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay = deque(maxlen=replay_size) #experience replay buffer\n",
    "lr = 0.0001 #learning rate\n",
    "gamma = 0.1 #discount factor\n",
    "epochs = 1300\n",
    "eps = 0.20 #starting epsilon for epsilon-greedy policy\n",
    "eps_min = 0.05 #ending epsilon\n",
    "priority_level = 10 #prioritized-replay; duplicate high-value experiences in the replay\n",
    "update_freq = 25 #update the target network every 100 steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Initialize DQN parameter vector\n",
    "tot_params = 128*100 + 25*100 + aspace*25*51  #total number of parameters for dist-DQN\n",
    "theta = torch.randn(tot_params)/10. #randomly initialize parameters for dist-DQN\n",
    "theta.requires_grad=True\n",
    "theta_2 = theta.detach().clone() #initialize paramaters for target network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started\n",
      "Won at i=693\n",
      "Won at i=824\n",
      "Won at i=1048\n",
      "Won at i=1200\n",
      "Won at i=1299\n",
      "CPU times: user 1min 44s, sys: 1 s, total: 1min 45s\n",
      "Wall time: 1min 51s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "#2min w/o frame rendering\n",
    "#main training loop\n",
    "losses = []\n",
    "cum_rewards = [] #stores each win (successful freeway crossing)\n",
    "renders = []\n",
    "state = preproc_state(env.reset())\n",
    "\n",
    "for i in range(epochs):\n",
    "    #get Q-distribution, take action\n",
    "    pred = dist_dqn(state,theta,aspace=aspace)\n",
    "    if i < replay_size or np.random.rand(1) < eps:\n",
    "        action = np.random.randint(aspace)\n",
    "    else:\n",
    "        action = get_action(pred.unsqueeze(dim=0).detach(),support).item()\n",
    "    state2, reward, done, info = env.step(action)\n",
    "    state2 = preproc_state(state2)\n",
    "    #\n",
    "    if reward == 1: cum_rewards.append(1) \n",
    "    reward = 10 if reward == 1 else reward\n",
    "    reward = -10 if done else reward\n",
    "    reward = -1 if reward == 0 else reward\n",
    "    #\n",
    "    '''if i % 5 == 0:\n",
    "        render_image = get_dist_plot(env,pred,support)\n",
    "        renders.append(render_image)'''\n",
    "    #\n",
    "    #add experience to replay buffer\n",
    "    exp = (state,action,reward,state2)\n",
    "    replay.append(exp)\n",
    "    \n",
    "    if reward == 10: #prioritized replay\n",
    "        print(\"Won at i={}\".format(i,))\n",
    "        for e in range(priority_level):\n",
    "            replay.append(exp)\n",
    "            \n",
    "    shuffle(replay)\n",
    "    # update state\n",
    "    state = state2\n",
    "    \n",
    "    #Train with a mini-batch\n",
    "    if i == replay_size+1:\n",
    "        print(\"Training started\")\n",
    "    if len(replay) == replay_size:\n",
    "        #collect mini-batch\n",
    "        indx = np.random.randint(low=0,high=len(replay),size=batch_size)\n",
    "        exps = [replay[j] for j in indx]\n",
    "        state_batch = torch.stack([ex[0] for ex in exps],dim=1).squeeze()\n",
    "        action_batch = torch.Tensor([ex[1] for ex in exps])\n",
    "        reward_batch = torch.Tensor([ex[2] for ex in exps])\n",
    "        state2_batch = torch.stack([ex[3] for ex in exps],dim=1).squeeze()\n",
    "        #\n",
    "        pred_batch = dist_dqn(state_batch.detach(),theta,aspace=aspace)\n",
    "        pred2_batch = dist_dqn(state2_batch.detach(),theta_2,aspace=aspace)\n",
    "        #\n",
    "        target_dist = get_target_dist(pred2_batch,action_batch,reward_batch, \\\n",
    "                                     support, lim=(vmin,vmax),gamma=gamma)\n",
    "        loss = lossfn(pred_batch,target_dist.detach())\n",
    "        losses.append(loss.item())\n",
    "        loss.backward()\n",
    "        # Gradient Descent\n",
    "        with torch.no_grad():\n",
    "            theta -= lr * theta.grad\n",
    "        theta.requires_grad = True\n",
    "        \n",
    "    if i % update_freq == 0: #sync target network parameters with main model parameters\n",
    "        theta_2 = theta.detach().clone()\n",
    "        \n",
    "    #Decrement `eps`\n",
    "    if i > 100 and eps > eps_min:\n",
    "        dec = 1./np.log2(i)\n",
    "        dec /= 1e3\n",
    "        eps -= dec\n",
    "    \n",
    "    #Reset env if done\n",
    "    if done:\n",
    "        state = preproc_state(env.reset())\n",
    "        done = False\n",
    "        print(\"End of game.\")\n",
    "\n",
    "#Stack generated frames into a movie\n",
    "if len(renders) > 1:\n",
    "    renders = np.stack(renders,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "#renders = np.stack(renders,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1c32dc8390>]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(9,5))\n",
    "plt.plot(losses)\n",
    "#plt.savefig(\"/Users/brandonbrown/Dropbox/DeepReinforcementLearning/media/Ch 7/lossplot.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 1, 1, 1]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cum_rewards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done.\n"
     ]
    }
   ],
   "source": [
    "#Create mp4 video from rendered numpy frames\n",
    "skvideo.io.vwrite(\"freeway_g0p2_5000f.mp4\", renders)\n",
    "print(\"Done.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Display the reward distributions for each action for a random sample of 5 experiences in the replay buffer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tpred = pred_batch\n",
    "#tpred = target_dist\n",
    "cs = ['gray','green','red']\n",
    "num_batch = 5\n",
    "batch_ind = np.random.randint(0,tpred.shape[0],num_batch)\n",
    "labels = ['Action {}'.format(i,) for i in range(aspace)]\n",
    "fig,ax = plt.subplots(nrows=num_batch,ncols=aspace)\n",
    "fig.set_size_inches((15,15))\n",
    "for j_ in range(num_batch): #loop through 5 first experiences in batch\n",
    "    j = batch_ind[j_]\n",
    "    for i in range(tpred.shape[1]): #loop through actions\n",
    "        ax[j_,i].bar(support.data.numpy(),tpred[j,i,:].data.numpy(),\\\n",
    "                label='Action {}'.format(i),alpha=0.9,color=cs[i])\n",
    "        ev = support.data.numpy() @ tpred[j,i,:].data.numpy()\n",
    "        ax[j_,i].set_title(\"$\\mathbb{E} = $\" + str(ev))\n",
    "fig.tight_layout()\n",
    "#fig.savefig(\"/Users/brandonbrown/Dropbox/DeepReinforcementLearning/media/Ch 7/act_dist_examples.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {},
   "outputs": [],
   "source": [
    "#[r for (s,a,r,s) in replay]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/brandonbrown/anaconda3/envs/deeprl/lib/python3.6/site-packages/ipykernel/__main__.py:37: DeprecationWarning: The binary mode of fromstring is deprecated, as it behaves surprisingly on unicode inputs. Use frombuffer instead\n",
      "/Users/brandonbrown/anaconda3/envs/deeprl/lib/python3.6/site-packages/skimage/util/dtype.py:135: UserWarning: Possible precision loss when converting from float64 to uint8\n",
      "  .format(dtypeobj_in, dtypeobj_out))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, "
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "See what actions the Dist-DQN produces after training. It should be predicting action UP (1) most often.\n",
    "\"\"\"\n",
    "state = preproc_state(env.reset())\n",
    "for i in range(20):\n",
    "    pred = dist_dqn(state,theta_2,3)\n",
    "    image = get_dist_plot(env,pred,support,shape=(210,160,3))\n",
    "    action = get_action(pred.unsqueeze(dim=0).detach(),support).item()\n",
    "    print(action,end=\", \")\n",
    "    s,r,d,i = env.step(action)\n",
    "    state = preproc_state(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,9))\n",
    "plt.imshow(image)\n",
    "#kplt.savefig(\"/Users/brandonbrown/Dropbox/DeepReinforcementLearning/media/Ch 7/sidebysidevideoframe.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:deeprl]",
   "language": "python",
   "name": "conda-env-deeprl-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
